// 引入需要的模块
const app = getApp();
const tokenManager = require('../../utils/tokenManager');
const storage = require('../../utils/storage.js');

Page({
  data: {
    userInfo: {
      avatarUrl: 'https://objectstorageapi.bja.sealos.run/a0qepsyj-001/text/profile/default-avatar.jpg',
      nickName: 'NAME',
      school: '绵阳师范学院',
      introduction: '热爱编程和技术探索，擅长前端开发和小程序应用',
      follows: '14',
      fans: '20k',
      likes: '200k',
      friends: '32',
      tags: ['二次元', '编程', '动漫', '前端', 'JavaScript']
    },
    activeTab: 'dynamic',
    showFullIntro: false,
    dynamicList: [] // 动态列表数据
  },
  
  onLoad: function (options) {
    console.log('profile页面加载');
    
    // 获取用户信息 - 先尝试从本地存储获取
    this.getUserInfoFromStorage();
    
    // 然后尝试从API获取最新信息
    this.getUserInfo();
    
    // 加载动态数据
    this.loadDynamicData();
    
    // 注册页面实例
    app.registerPageInstance(this);
    
    // 注册头像更新事件监听
    app.on('avatarUpdate', this.handleAvatarUpdate, this);
  },
  
  onUnload: function () {
    // 注销页面实例
    app.unregisterPageInstance(this);
    
    // 注销事件监听
    app.off('avatarUpdate', this.handleAvatarUpdate);
  },
  
  // 处理头像更新事件
  handleAvatarUpdate: function(avatarUrl) {
    console.log('接收到头像更新事件', avatarUrl);
    
    if (!avatarUrl) return;
    
    // 更新本地头像
    const userInfo = this.data.userInfo || {};
    userInfo.avatarUrl = avatarUrl;
    
    this.setData({
      userInfo: userInfo
    });
    
    // 强制重新加载图片
    storage.reloadImage(avatarUrl)
      .then(() => {
        console.log('头像更新成功');
      })
      .catch(err => {
        console.error('头像更新失败', err);
      });
  },
  
  // 刷新用户信息（供全局调用）
  refreshUserInfo(eventData) {
    console.log('刷新用户信息', eventData);
    
    // 获取最新用户信息
    this.getUserInfoFromStorage();
    
    // 如果有特定的事件数据，进行额外处理
    if (eventData) {
      if (eventData.hasIdentityInfo !== undefined) {
        // 更新学生身份信息状态
        this.setData({
          'userInfo.hasIdentityInfo': eventData.hasIdentityInfo
        });
      }
      
      if (eventData.avatar) {
        // 更新头像URL，添加时间戳以防止缓存
        const timestamp = new Date().getTime();
        this.setData({
          'userInfo.avatar': `${eventData.avatar}?t=${timestamp}`
        });
      }
    }
    
    // 刷新页面内其他动态数据
    this.loadDynamicData();
  },
  
  getUserInfo() {
    console.log('开始获取用户信息');
    
    // 显示加载中
    wx.showLoading({
      title: '加载中',
      mask: true
    });
    
    // 判断是否已登录
    if (tokenManager.isLoggedIn()) {
      // 获取token
      const token = tokenManager.getAccessToken();
      
      // 如果有token，尝试从API获取用户信息
      app.api.user.getProfile(token).then(userInfo => {
        console.log('API返回的用户信息:', userInfo);
        
        // 合并API返回的用户信息和统计数据
        const statsData = {
          follows: this.data.userInfo.follows,
          fans: this.data.userInfo.fans,
          likes: this.data.userInfo.likes,
          friends: this.data.userInfo.friends,
          tags: this.data.userInfo.tags || ['二次元', '编程', '动漫', '前端', 'JavaScript']
        };
        
        // API返回的用户信息可能字段名与本地不同，需要映射
        const mappedUserInfo = {
          avatarUrl: userInfo.avatar || this.data.userInfo.avatarUrl,
          nickName: userInfo.nickname || this.data.userInfo.nickName,
          school: userInfo.school || this.data.userInfo.school,
          introduction: userInfo.introduction || this.data.userInfo.introduction,
          // 其他字段映射
          email: userInfo.email,
          phone: userInfo.phone
        };
        
        // 如果有头像URL，添加时间戳防止缓存
        if (mappedUserInfo.avatarUrl) {
          const timestamp = Date.now();
          mappedUserInfo.avatarUrl = mappedUserInfo.avatarUrl.includes('?') 
            ? `${mappedUserInfo.avatarUrl}&t=${timestamp}` 
            : `${mappedUserInfo.avatarUrl}?t=${timestamp}`;
            
          // 强制重新加载图片
          storage.reloadImage(mappedUserInfo.avatarUrl)
            .then(() => {
              console.log('头像刷新成功');
            })
            .catch(err => {
              console.error('头像刷新失败', err);
            });
        }
        
        // 合并数据
        const mergedUserInfo = {...this.data.userInfo, ...mappedUserInfo, ...statsData};
        
        console.log('合并后的用户信息:', mergedUserInfo);
        
        // 更新页面数据
        this.setData({ userInfo: mergedUserInfo });
        
        // 保存到本地缓存
        wx.setStorageSync('userInfo', mergedUserInfo);
        
        wx.hideLoading();
      }).catch(error => {
        console.error('获取用户信息失败', error);
        // API获取失败，尝试本地存储
        this.getUserInfoFromStorage();
        wx.hideLoading();
        
        // 显示错误提示
        wx.showToast({
          title: '获取API信息失败，使用本地数据',
          icon: 'none',
          duration: 2000
        });
      });
    } else {
      // 未登录，使用本地存储
      this.getUserInfoFromStorage();
      wx.hideLoading();
    }
  },
  
  // 从本地存储获取用户信息
  getUserInfoFromStorage() {
    console.log('从本地存储获取用户信息');
    
    try {
      const storageUserInfo = wx.getStorageSync('userInfo');
      console.log('本地存储的用户信息:', storageUserInfo);
      
      if (storageUserInfo) {
        // 处理字段名差异
        let displayUserInfo = {
          ...storageUserInfo,
          // 确保avatar字段存在（优先使用avatarUrl，如果没有则使用avatar）
          avatar: storageUserInfo.avatarUrl || storageUserInfo.avatar,
          // 确保avatarUrl字段存在（优先使用avatarUrl，如果没有则使用avatar）
          avatarUrl: storageUserInfo.avatarUrl || storageUserInfo.avatar,
          // 确保nickname字段存在（优先使用nickname，如果没有则使用nickName）
          nickname: storageUserInfo.nickname || storageUserInfo.nickName,
          // 确保nickName字段存在（优先使用nickName，如果没有则使用nickname）
          nickName: storageUserInfo.nickName || storageUserInfo.nickname
        };
        
        // 如果有头像URL，强制添加时间戳防止缓存
        if (displayUserInfo.avatarUrl) {
          const timestamp = Date.now();
          let avatarUrl = displayUserInfo.avatarUrl;
          
          // 检查URL是否已经有时间戳参数
          if (avatarUrl.indexOf('t=') === -1) {
            avatarUrl = avatarUrl.includes('?') 
              ? `${avatarUrl}&t=${timestamp}` 
              : `${avatarUrl}?t=${timestamp}`;
          }
          
          displayUserInfo.avatarUrl = avatarUrl;
          displayUserInfo.avatar = avatarUrl; // 同时更新两个字段
          
          // 强制重新加载图片
          storage.reloadImage(avatarUrl)
            .then(() => {
              console.log('头像刷新成功');
            })
            .catch(err => {
              console.error('头像刷新失败', err);
            });
        }
        
        this.setData({ userInfo: displayUserInfo });
      } else {
        // 没有存储的数据时，将当前数据保存到存储
        wx.setStorageSync('userInfo', this.data.userInfo);
      }
    } catch (e) {
      console.error('获取本地用户信息失败', e);
    }
  },
  
  // 加载动态数据
  loadDynamicData() {
    // 模拟动态数据
    const dynamicList = [
      {
        id: 'dynamic001',
        title: '技术分享：小程序开发心得',
        nickName: '张小明',
        avatar: 'https://objectstorageapi.bja.sealos.run/a0qepsyj-001/text/profile/default-avatar.jpg',
        content: '今天给大家分享一下小程序开发的一些经验和技巧，希望对大家有所帮助。首先，我们需要了解小程序的基本架构...',
        views: 1024,
        time: '2023-03-26'
      },
      {
        id: 'dynamic002',
        title: '参加了校园编程大赛',
        nickName: '李华',
        avatar: 'https://objectstorageapi.bja.sealos.run/a0qepsyj-001/text/profile/default-avatar.jpg',
        content: '昨天参加了学校举办的编程大赛，虽然没有获得冠军，但收获了很多经验和友谊，感谢一路上支持我的朋友们！',
        views: 567,
        time: '2023-03-25'
      },
      {
        id: 'dynamic003',
        title: '分享一个有趣的项目',
        nickName: '王大力',
        avatar: 'https://objectstorageapi.bja.sealos.run/a0qepsyj-001/text/profile/default-avatar.jpg',
        content: '最近在做一个基于人工智能的小游戏，使用了一些有趣的算法和设计理念，希望大家能给我一些建议和反馈。',
        views: 832,
        time: '2023-03-24'
      }
    ];
    
    this.setData({ dynamicList });
  },
  
  // 跳转到身份信息表单
  navigateToIdentityForm() {
    const app = getApp();
    const tokenManager = require('../../utils/tokenManager');
    
    // 检查是否登录
    if (!tokenManager.isLoggedIn()) {
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 2000
      });
      
      // 跳转到登录页面
      setTimeout(() => {
        wx.navigateTo({
          url: '/pages/login/login'
        });
      }, 1500);
      return;
    }
    
    // 跳转到身份表单页
    wx.navigateTo({
      url: '/pages/identity-form/identity-form',
      events: {
        // 监听表单提交事件
        formSubmitted: (data) => {
          console.log('身份表单提交成功，刷新个人信息', data);
          // 刷新用户信息
          this.getUserInfoFromStorage();
          
          // 更新学生卡片状态
          if (data && data.success) {
            this.setData({
              'userInfo.hasIdentityInfo': true
            });
            
            // 更新全局用户信息
            if (app.globalData.userInfo) {
              app.globalData.userInfo.hasIdentityInfo = true;
            }
            
            // 触发用户信息更新事件
            app.triggerEvent('userInfoUpdated', {
              hasIdentityInfo: true,
              timestamp: new Date().getTime()
            });
          }
        }
      },
      success: (res) => {
        // 传递当前用户信息到身份表单页面
        res.eventChannel.emit('acceptUserInfo', { userInfo: this.data.userInfo });
      }
    });
  },
  
  // 跳转到MBTI测试页面
  navigateToMbtiTest() {
    wx.navigateTo({
      url: '/pages/mbti/mbti'
    });
  },
  
  // 切换标签页
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    this.setData({
      activeTab: tab
    });
    
    // 根据不同标签加载不同数据
    if (tab === 'dynamic' && this.data.dynamicList.length === 0) {
      this.loadDynamicData();
    }
  },
  
  // 编辑资料
  editProfile() {
    // 检查用户是否登录
    const app = getApp();
    const tokenManager = require('../../utils/tokenManager');
    
    if (!tokenManager.isLoggedIn()) {
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 2000
      });
      
      // 跳转到登录页
      setTimeout(() => {
        wx.navigateTo({
          url: '/pages/login/login'
        });
      }, 1500);
      return;
    }
    
    // 已有编辑页面，直接跳转
    wx.navigateTo({
      url: '/pages/edit-profile/edit-profile',
      events: {
        // 监听编辑页面保存成功后的事件
        profileUpdated: () => {
          // 重新加载用户数据
          this.getUserInfo();
        }
      },
      success: (res) => {
        // 传递当前用户信息
        res.eventChannel.emit('userData', this.data.userInfo);
      }
    });
  },
  
  // 导航到头像编辑页面
  navigateToAvatarEdit() {
    console.log('跳转到头像编辑页面');
    
    // 检查用户是否登录
    if (!tokenManager.isLoggedIn()) {
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 2000
      });
      
      // 跳转到登录页
      setTimeout(() => {
        wx.navigateTo({
          url: '/pages/login/login'
        });
      }, 1500);
      return;
    }
    
    // 清除当前头像缓存
    const userInfo = this.data.userInfo;
    if (userInfo && userInfo.avatarUrl) {
      storage.clearWxImageCache(userInfo.avatarUrl);
    }
    
    // 跳转到头像编辑页面
    wx.navigateTo({
      url: '/pages/avatar-edit/avatar-edit',
      success: () => {
        console.log('成功跳转到头像编辑页面');
      },
      fail: (err) => {
        console.error('跳转到头像编辑页面失败:', err);
        wx.showToast({
          title: '打开页面失败',
          icon: 'none'
        });
      }
    });
  },
  
  // 导航到昵称编辑页面
  navigateToNicknameEdit() {
    console.log('跳转到昵称编辑页面');
    
    // 检查用户是否登录
    if (!tokenManager.isLoggedIn()) {
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        duration: 2000
      });
      
      // 跳转到登录页
      setTimeout(() => {
        wx.navigateTo({
          url: '/pages/login/login'
        });
      }, 1500);
      return;
    }
    
    // 跳转到编辑资料页面，并指定焦点为昵称
    wx.navigateTo({
      url: '/pages/edit-profile/edit-profile?focus=nickname',
      events: {
        // 监听编辑页面保存成功后的事件
        profileUpdated: () => {
          // 重新加载用户数据
          this.getUserInfo();
        }
      },
      success: (res) => {
        // 传递当前用户信息
        res.eventChannel.emit('userData', this.data.userInfo);
      },
      fail: (err) => {
        console.error('跳转到昵称编辑页面失败:', err);
        wx.showToast({
          title: '打开页面失败',
          icon: 'none'
        });
      }
    });
  },
  
  // 导航到设置页面
  navigateToSettings() {
    wx.navigateTo({
      url: '/pages/settings/settings'
    });
  },
  
  // 显示简介
  toggleIntro() {
    wx.showModal({
      title: '个人简介',
      content: this.data.userInfo.introduction || '暂无简介',
      showCancel: false,
      confirmText: '确定'
    });
  },
  
  // 导航到关注列表
  navigateToFollows() {
    wx.navigateTo({
      url: '/pages/user-list/user-list?type=follow'
    });
  },
  
  // 导航到粉丝列表
  navigateToFans() {
    wx.navigateTo({
      url: '/pages/user-list/user-list?type=fan'
    });
  },
  
  // 导航到被喜欢列表
  navigateToLikes() {
    wx.navigateTo({
      url: '/pages/user-list/user-list?type=like'
    });
  },
  
  // 导航到好友列表
  navigateToFriends() {
    wx.navigateTo({
      url: '/pages/user-list/user-list?type=friend'
    });
  },
  
  // 导航到动态详情
  navigateToDetail(e) {
    const dynamicId = e.currentTarget.dataset.id;
    wx.navigateTo({
      url: `/pages/dynamic-detail/dynamic-detail?id=${dynamicId}`
    });
  },
  
  // 收藏操作
  handleCollect(e) {
    const index = e.currentTarget.dataset.index;
    wx.showToast({
      title: '已收藏',
      icon: 'success'
    });
  },
  
  // 分享操作
  handleShare(e) {
    const index = e.currentTarget.dataset.index;
    wx.showShareMenu({
      withShareTicket: true,
      menus: ['shareAppMessage', 'shareTimeline']
    });
  },
  
  // 评论操作
  handleComment(e) {
    const index = e.currentTarget.dataset.index;
    const dynamicId = this.data.dynamicList[index].id;
    wx.navigateTo({
      url: `/pages/dynamic-detail/dynamic-detail?id=${dynamicId}&showComment=true`
    });
  },
  
  // 围观操作
  handleWatch(e) {
    const index = e.currentTarget.dataset.index;
    wx.showToast({
      title: '已围观',
      icon: 'success'
    });
  },
  
  // 页面显示时，刷新用户信息
  onShow: function() {
    // 每次页面显示时都刷新用户信息
    this.loadUserInfo();
  },
  
  loadUserInfo: function() {
    const app = getApp();
    const tokenManager = require('../../utils/tokenManager');
    
    if (!tokenManager.isLoggedIn()) {
      console.log('用户未登录');
      return;
    }
    
    const token = tokenManager.getAccessToken();
    
    // 显示加载状态
    wx.showLoading({
      title: '加载中...',
      mask: true
    });
    
    // 获取用户基本资料
    app.api.user.getProfile(token)
      .then(profile => {
        wx.hideLoading();
        console.log('获取到的用户基本资料:', profile);
        
        if (profile) {
          // 更新性别显示
          const genderMap = {
            'M': '男',
            'F': '女',
            'O': '其他'
          };
          
          // 更新用户信息
          this.setData({
            userInfo: {
              ...this.data.userInfo,
              nickName: profile.nickname || '',
              gender: profile.gender ? genderMap[profile.gender] : '',
              email: profile.email || '',
              phone: profile.phone || '',
              avatarUrl: profile.avatar || this.data.userInfo.avatarUrl
            }
          });
          
          // 保存到本地存储
          wx.setStorageSync('userInfo', this.data.userInfo);
        }
      })
      .catch(error => {
        wx.hideLoading();
        console.error('获取用户基本资料失败:', error);
      });
  },
  
  // 获取缓存中的用户信息
  getUserInfoFromStorage: function() {
    // 这里改用我们的刷新方法，确保头像能够正确显示
    this.refreshUserInfo();
  },
  
  // 点击头像进入头像编辑页
  onTapAvatar: function() {
    if (!app.tokenManager.isLoggedIn()) {
      return this.goToLogin();
    }
    
    // 清除头像缓存，确保编辑页显示最新头像
    const userInfo = this.data.userInfo;
    if (userInfo && userInfo.avatarUrl) {
      storage.clearWxImageCache(userInfo.avatarUrl);
    }
    
    wx.navigateTo({
      url: '/pages/avatar-edit/avatar-edit'
    });
  },
  
  // 分享到朋友圈
  onShareTimeline() {
    return {
      title: `${this.data.userInfo.nickName}的个人主页`,
      imageUrl: this.data.userInfo.avatarUrl
    };
  },
  
  // 分享给朋友
  onShareAppMessage() {
    return {
      title: `${this.data.userInfo.nickName}的个人主页`,
      path: '/pages/profile/profile',
      imageUrl: this.data.userInfo.avatarUrl
    };
  }
});